package com.ebupt.migu.music.iop.service.impl;

import com.alibaba.fastjson.JSON;
import com.ebupt.migu.music.common.constants.UserGroupConstants;
import com.ebupt.migu.music.common.entity.ResultObject;
import com.ebupt.migu.music.common.exception.MyException;
import com.ebupt.migu.music.common.exception.StatusEnum;
import com.ebupt.migu.music.common.util.DateUtil;
import com.ebupt.migu.music.iop.service.IopGroupServce;
import com.ebupt.migu.music.userGroup.entity.ActiveArrayBean;
import com.ebupt.migu.music.userGroup.entity.AttributeBean;
import com.ebupt.migu.music.userGroup.mapper.CrowdMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.util.*;

/**
 * iop标签标签客群
 * @author wz
 */
@Slf4j
@Service
public class iopGroupServceImpl implements IopGroupServce {


    @Autowired
    private CrowdMapper crowdMapper;

    @Value("${label.prefix}")
    private String LABEL_PREFIX;

    @Value("${label.customer_valid}")
    private String CUSTOMER_VALID;

    @Override
    public ResultObject createByLabel(Map<String, Object> params) {
        System.out.println("请求参数:"+params.toString());

        ResultObject res = new ResultObject();
        // 验证是否需要存入草稿箱 1-非草稿箱； 0-草稿箱；
        if (null == params.get("saveType")) {
            throw new MyException(StatusEnum.BUSINID, "saveType参数不可为空！");
        }

        int saveType = Integer.parseInt(params.get("saveType").toString());

        if (saveType != 0 && saveType != 1) {
            throw new MyException(StatusEnum.BUSINID, "saveType参数值错误！");
        }

        // 验证用户群名称
        if (null == params.get("userGroupName") || StringUtils.isBlank(params.get("userGroupName").toString())) {
            throw new MyException(StatusEnum.BUSINID, "用户群名称不可为空！");
        }

        String userGroupName = params.get("userGroupName").toString();

        String gid = "CD" + DateUtil.parseDateToStr(new Date(), DateUtil.DATE_TIME_FORMAT_YYYYMMDDHHMISS);
        params.put("groupId", gid);
        // 判断人群名称是否存被占用
        Map<String, Object> map = new HashMap<>();
        map.put("userGroupName", userGroupName);
        map.put("groupId", gid);

        if (crowdMapper.isUserGroupNameExistCnt(map) > 0) {
            throw new MyException(StatusEnum.NAME_ALREADY_EXIST, "人群名称被占用，请尝试换一个人群名称！");
        }

        // 保存到草稿箱
        if (saveType == 0) {
            try {
                //检查数据库是否存在同名用户群:1- 存在同名用户群则更新当前用户群； 2- 没有则创建新的用户群；
                HashMap<String, Object> isExist = crowdMapper.isUserGroupNameExist(params.get("userGroupName").toString());
                if (isExist == null) {
                    // 创建状态设置为保存入草稿箱
                    // 默认是动态标签创建
                    params.put("createWay", UserGroupConstants.CREATE_BY_IOP);
                    params.put("createStatus", UserGroupConstants.WAITING_FOR_SUBMISSION);
                    crowdMapper.deleteCustomerTmp(params);
                    crowdMapper.createUserGroup(params);
                } else {
                    // 根据用户群ID更新人群信息
                    params.put("groupId", isExist.get("groupId").toString());
                    crowdMapper.updateCrowd(params);
                }
            } catch (Exception e) {
                log.error("保存草稿箱失败！", e);
                throw new MyException(StatusEnum.CREATE_USER_GROUP_ERROR, "自动保存草稿箱失败！");
            }
            res.setMsg("保存草稿箱成功！");
            return res;
        }
        params.put("createWay", UserGroupConstants.CREATE_BY_IOP);
        params.put("createStatus", UserGroupConstants.BEING_CREATED);
        // 客群有效信息上报
        crowdMapper.deleteCustomerTmp(params);
        crowdMapper.createUserGroup(params);
        if (null !=  params.get("regulation")) {
            Map<Object, Object> hashMap = new HashMap<>();
            hashMap.put("groupId", gid);
            hashMap.put("regulationInfo",params.get("regulation") );
            hashMap.put("state", 0);
            crowdMapper.createIopInfo(hashMap);
        }
        res.setMsg("创建成功！");
        return res;
    }

    @Override
    public ResultObject updateCrowd(Map<String, Object> params) {
        if (null == params.get("groupId") || StringUtils.isBlank(params.get("groupId").toString())) {
            throw new MyException(StatusEnum.BUSINID, "用户群ID不可为空！");
        }
        String gid = params.get("groupId").toString();
        // 查询当前人群是否参与人群重组
        List<HashMap<String, Object>> infos = crowdMapper.queryResGroups(gid);
        List<String> gids = new ArrayList<>();
        if (!infos.isEmpty()) {
            for (Map<String, Object> info : infos) {
                // 将参与重组之后的人群名称保存下来
                gids.add(info.get("userGroupName").toString());
            }
            log.info("该用户群体已经被{}重组引用", gids.toString());
        }
        // 查询当前人群是否参与策略运营
        List<HashMap<String, Object>> strategys = crowdMapper.queryPartInStrategy(gid);
        if (!strategys.isEmpty()) {
            for (Map<String, Object> strategy : strategys) {
                // 将参与的策略名称保存下来
                gids.add(strategy.get("strategyName").toString());
            }
            log.info("该用户群体正在参与{}活动的运营", gids.toString());
        }

        try {
            int saveType = Integer.parseInt(params.get("saveType").toString());
            if (saveType == 0) {
                // 创建状态设置为保存入草稿箱
                // 默认是动态标签创建
                params.put("createWay", UserGroupConstants.CREATE_BY_DYNAMIC_LABEL);
                params.put("createStatus", UserGroupConstants.WAITING_FOR_SUBMISSION);
            } else {
                    params.put("createWay", UserGroupConstants.CREATE_BY_IOP);
                    params.put("createStatus", UserGroupConstants.BEING_CREATED);
            }
            crowdMapper.updateCrowd(params);
        } catch (Exception e) {
            log.error("更新人群信息失败：" + params.get("groupId").toString(), e);
            throw new MyException(StatusEnum.UPDATE_USER_GROUP_ERROR, "更新用户群信息失败");
        }
        ResultObject res = new ResultObject();
        res.setMsg("更新成功！");
        return res;
    }

    @Override
    public ResultObject deleteCrowd(Map<String, Object> params) {
        ResultObject res = new ResultObject();
        if (null == params.get("groupId") || StringUtils.isBlank(params.get("groupId").toString())) {
            throw new MyException(StatusEnum.BUSINID, "用户群ID不可为空！");
        }
        String gid = params.get("groupId").toString();
        // 查询当前人群是否参与人群重组
        List<HashMap<String, Object>> infos = crowdMapper.queryResGroups(gid);
        List<String> gids = new ArrayList<>();
        if (!infos.isEmpty()) {
            for (Map<String, Object> info : infos) {
                // 将参与重组之后的人群名称保存下来
                gids.add(info.get("userGroupName").toString());
            }
            res.setCode(StatusEnum.PART_IN_RECOMBINE.getCode());
            res.setMsg("该用户群体已被" + gids.toString() + "重组引用，请先删除该用户群，再进行删除。");
            return res;
            // throw new PromptException(StatusEnum.PART_IN_RECOMBINE, "该用户群体已被" + gids.toString() +
            // "重组引用，请先删除该用户群，再进行删除。");
        }
        // 查询当前人群是否参与策略运营
        List<HashMap<String, Object>> strategys = crowdMapper.queryPartInStrategy(gid);
        if (!strategys.isEmpty()) {
            for (Map<String, Object> strategy : strategys) {
                // 将参与的策略名称保存下来
                gids.add(strategy.get("strategyName").toString());
            }
            res.setCode(StatusEnum.PART_IN_OPERATE.getCode());
            res.setMsg("该用户群体正在参与" + gids.toString() + "活动的运营，暂不能删除。");
            return res;
            // throw new PromptException(StatusEnum.PART_IN_OPERATE, "该用户群体正在参与" + gids.toString() + "活动的运营，暂不能删除。");
        }
        // 未参与人群重组且未参与策略运营的人群才可以被删除
        try {
            params.put("createStatus", UserGroupConstants.DELETED);
            crowdMapper.updateCrowd(params);
        } catch (Exception e) {
            log.error("删除人群失败：" + gid, e);
            throw new MyException(StatusEnum.DELETE_USER_GROUP_ERROR, "删除人群失败！");
        }
        res.setMsg("删除成功！");
        return res;
    }

    @Override
    public ResultObject data(Map<String, Object> params) {
        ResultObject res = new ResultObject();
        String s = params.get("groupId").toString();
        HashMap<String, Object> stringObjectHashMap = crowdMapper.queryByGroupID(s);
        res.setData(stringObjectHashMap);
        return res;
    }

    /**
     * 验证人群是否由动态标签创建
     *
     * @param json
     * @return
     */
    public boolean isDyna(String json) {
        if (StringUtils.isBlank(json)) {
            throw new MyException(StatusEnum.BUSINID, "标签属性不可为空！");
        }

        //JSON转换成对应的JavaBean
        AttributeBean bean = JSON.parseObject(json, AttributeBean.class);

        //时间类型  1：过去时段 2 ：未来时段 3：过去某天 4：未来某天 5：自定义区间 6：过去时段（周）7:过去某周
        if (StringUtils.isNotBlank(bean.getDateType())) {
            return true;
        }
        // 来源平台页面选择
        // 1：咪咕音乐 2：DPI
        if (StringUtils.isNotBlank(bean.getUserRadio()) && "2".equals(bean.getUserRadio())) {
            return true;
        }
        //时间选择-开始时间
        if (StringUtils.isNotBlank(bean.getDateStart())) {
            return true;
        }
        //时间选择-结束时间
        if (StringUtils.isNotBlank(bean.getDateEnd())) {
            return true;
        }
        //具体天数 (日 或者 周)
        if (StringUtils.isNotBlank(bean.getDateType()) && StringUtils.isNotBlank(bean.getDayCont())) {
            return true;
        }
        //日期区间类型 1：过去 2：未来
        if (StringUtils.isNotBlank(bean.getSectionType())) {
            return true;
        }
        //未来时间区间
        if (!"[]".equals(bean.getDate1())) {
            return true;
        }
        //过去时间区间
        if (!"[]".equals(bean.getDate2())) {
            return true;
        }
        //周
        if (StringUtils.isNotBlank(bean.getWeek())) {
            return true;
        }
        //周选择日期
        if (StringUtils.isNotBlank(bean.getWeekPc())) {
            return true;
        }
        //是否是音频彩铃用户 1 音频彩铃用户 0 不是
        if (StringUtils.isNotBlank(bean.getCringType())) {
            return true;
        }
        //是否是音频彩铃用户 1 音频彩铃用户 0 不是
        if (StringUtils.isNotBlank(bean.getCringTypePc())) {
            return true;
        }
        //是否是视频彩铃用户 1 音频彩铃用户 0 不是
        if (StringUtils.isNotBlank(bean.getVedioCringType())) {
            return true;
        }
        //是否是视频彩铃用户 1 音频彩铃用户 0 不是
        if (StringUtils.isNotBlank(bean.getVedioCringTypePc())) {
            return true;
        }
        //是否是彩铃用户
        if (StringUtils.isNotBlank(bean.getIsMusicUser())) {
            return true;
        }
        //是否白金会员 1 白金会员 0 不是
        if (StringUtils.isNotBlank(bean.getPtFlag())) {
            return true;
        }
        //是否付费 1 付费  2 未付费
        if (StringUtils.isNotBlank(bean.getPtFeeFlag())) {
            return true;
        }
        //会员类型2 0.非会员 1.特级会员 2.高级会员 3.普通会员
        if (!"[]".equals(bean.getMemLevel())) {
            return true;
        }
        //白金会员类型 标识 1.大战包会员 2.标准版会员 3有效期白金会员 0.都不是
        if (!"[]".equals(bean.getPtType())) {
            return true;
        }
        //是否有效期白金会员 1 为是 0 为不是
        if (StringUtils.isNotBlank(bean.getPdValidFlag())) {
            return true;
        }
        //白金会员类型  中文
        if (StringUtils.isNotBlank(bean.getType())) {
            return true;
        }
        //行为状态  1 首次打开 2：持续沉默 3：开通白金会员 4：白金会员到期
        if (StringUtils.isNotBlank(bean.getNewUserFlag())) {
            return true;
        }
        //资源类型
        if (StringUtils.isNotBlank(bean.getResourceType())) {
            return true;
        }

        // 1:一元小包，2:3元小包，3:1元和3元小包
        if (StringUtils.isNotBlank(bean.getMonYuanFlag())) {
            return true;
        }

        List<ActiveArrayBean> actives = bean.getActiveArray();
        if (actives != null && actives.size() > 0) {
            return true;
        }

        /**
         * 视频彩铃id
         */
        if (StringUtils.isNotBlank(bean.getVedioCringId())) {
            return true;
        }

        /**
         * 视频彩铃风格
         */
        if (StringUtils.isNotBlank(bean.getVedioCringStyle())) {
            return true;
        }

        /**
         * 是否话费支付用户
         */
        if (StringUtils.isNotBlank(bean.getNormalHdFlag())) {
            return true;
        }

        /**
         * 是否第三方支付用户
         */
        if (StringUtils.isNotBlank(bean.getThridHdFlag())) {
            return true;
        }

        /**
         * 是否volte手机
         */
        if (StringUtils.isNotBlank(bean.getVolteFlag())) {
            return true;
        }

        /**
         * arpu值（月话费总额）
         */
        if (StringUtils.isNotBlank(bean.getArpuValue())) {
            return true;
        }

        /**
         * 时段偏好
         */
        if (StringUtils.isNotBlank(bean.getTimeFrame())) {
            return true;
        }

        return false;
    }

}
